﻿/*
* ========================================================================
* 类说明：
*   版本信息相关 CAN 指令操作
* 
* 作者：HGS   时间：2024/11/20 15:02:58
* 
* 修改者：         时间：           
* 修改说明：
* ========================================================================
*/

using EasyTest.Shared.EnumType;
using EasyTest.Shared.TestAttribute;
using EasyTest.Shared.外部访问;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Channels;

using ZLGCANoptimize.方法;

namespace ZLGCANoptimize
{

//    public class 版本信息新
//    {
//#if ELO20240927
//        [ExposedMethodAttribute("")]
//        public bool 读DSP软件版本号BE32(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 BE 32 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }
//                /*
//                    10 0D 62 BE 32 44 02 00
//                    21 02 44 24 06 01 00 00
//                */
//                //0D：结果数据长度
//                //62：通过表示符读取数据
//                //BE 32：数据DID
//                //21：固定连续帧的帧头
//                //解析结果中，需要将第0位(AB)Hex转int、第4位(IJ)Hex转int
//                //44 02 00 02 44 24 06 01（这里只是举例假设这是一个有效的hex字符串，方便理解）

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = CommonWay.HexToChar(发送响应.ResultHex.Substring(0, 2)) + 发送响应.ResultHex.Substring(2, 6) +
//                         CommonWay.HexToChar(发送响应.ResultHex.Substring(8, 2)) + 发送响应.ResultHex.Substring(10, 6);

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读DSP软件版本号BE32]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读DSP软件版本号BE32]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读MCUSDK软件版本号(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 B0 11 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = CommonWay.HexToChar(发送响应.ResultHex.Substring(0, 2)) + 发送响应.ResultHex.Substring(2, 6) +
//                         CommonWay.HexToChar(发送响应.ResultHex.Substring(8, 2)) + 发送响应.ResultHex.Substring(10, 6);

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读MCUSDK软件版本号]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读MCUSDK软件版本号]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//#else
//        [ExposedMethodAttribute("")]
//        public bool 读DSP软件版本号BE32(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 BE 32 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = CommonWay.HexToChar(发送响应.ResultHex.Substring(0, 2)) + CommonWay.HexToInt(发送响应.ResultHex.Substring(2, 2)) +
//                         CommonWay.HexToInt(发送响应.ResultHex.Substring(4, 2)) + CommonWay.HexToInt(发送响应.ResultHex.Substring(6, 2)) +
//                         CommonWay.HexToChar(发送响应.ResultHex.Substring(8, 2)) + 发送响应.ResultHex.Substring(10,6);

//                return true;
//            }
//            catch (Exception ex)
//            {
//                LogHelper.Error($"[版本信息.读DSP软件版本号BE32]异常，{ex.Message}，{ex.StackTrace}");
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读MCUSDK软件版本号(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";
//            bool flag2;
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 B0 11 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 3;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }
//                /*
//                    10 0D 62 BE 32 44 02 00
//                    21 02 44 24 06 01 00 00
//                */
//                //0D：结果数据长度
//                //62：通过表示符读取数据
//                //BE 32：数据DID
//                //21：固定连续帧的帧头
//                //解析结果中，需要将第0位(AB)Hex转int、第4位(IJ)Hex转int
//                //44 02 00 02 44 24 06 01（这里只是举例假设这是一个有效的hex字符串，方便理解）

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultHex.Insert(8,"/");

//                return true;
//            }
//            catch (Exception ex)
//            {
//                LogHelper.Error($"[版本信息.读MCUSDK软件版本号]异常，{ex.Message}，{ex.StackTrace}");
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//#endif

//        [ExposedMethodAttribute("")]
//        public bool 读取SN(int 通道, out string 响应值, out int SN字节长度, out string 信息)
//        {
//            信息 = "";
//            响应值 = "";
//            SN字节长度 = 响应值.Length;
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 8C 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 80;
//                requestModel.MaxSendCount = 1;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }
//                //03 7F 22 78 AA AA AA AA ,10 13 62 F1 8C 20 37 46 ,21 37 32 31 30 43 52 41 ,22 32 38 30 30 31 37 AA 
//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读取SN]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读取SN]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = "";
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool ECU应用软件(int 通道, out string 响应值, out int 字节长度, out string 信息, int ECU应用软件号 = 2)
//        {
//            信息 = "";
//            响应值 = "";
//            字节长度 = 响应值.Length;
//            try
//            {
//                string 命令 = "";
//                ECU应用软件Enum 目标枚举 = (ECU应用软件Enum)ECU应用软件号;
//                switch (目标枚举)
//                {
//                    case ECU应用软件Enum.二级://
//                        命令 = "03 22 F1 B5 00 00 00 00";
//                        break;
//                    case ECU应用软件Enum.三级:
//                        命令 = "03 22 F1 B6 00 00 00 00";
//                        break;
//                    case ECU应用软件Enum.四级:
//                        命令 = "03 22 F1 B7 00 00 00 00";
//                        break;
//                    case ECU应用软件Enum.五级:
//                        命令 = "03 22 F1 B8 00 00 00 00";
//                        break;
//                    case ECU应用软件Enum.六级:
//                        命令 = "03 22 F1 B9 00 00 00 00";
//                        break;
//                    default:
//                        命令 = "03 22 F1 B5 00 00 00 00";
//                        break;
//                }
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = 命令 });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 80;
//                requestModel.MaxSendCount = 1;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultHex.Insert(8,"/");

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.ECU应用软件]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.ECU应用软件]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 硬件版本号(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 87 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 3;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultAsc.Insert(4, "/");

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.硬件版本号]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.硬件版本号]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读取ECU零件号(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 87 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 3;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultAsc.Insert(4, "/");

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读取ECU零件号]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读取ECU零件号]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读取生产日期(int 通道, out string 响应值, out string 信息)
//        {
//            响应值 = "";
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 8B 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 3;
//                requestModel.AutoParse = false;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                //修改判断，只要是积极反馈即可，索引上面不需要自动解析，2024-11-07
//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = string.Join(",", 发送响应.ResultList);

//                //这里不一定会有06帧头数据？06表示的是长度，如果没写入，返回值是否为03？所以这里提取失败也不当失败处理，2024-11-21
//                var 提取结果 = 数据.GetFrameHeaderData(发送响应.ResultList, "06", out string 目标值);
//                if (提取结果)
//                {
//                    响应值 = 发送响应.ResultHex.Substring(8, 6);  //存在写入的生产日期数据，将此数据读取出来
//                }

//                if (!目标值.Contains("62F18B"))
//                {
//                    return false;  //未收到积极响应，当失败处理
//                }

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[ZLGCANoptimize.读取生产日期]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[ZLGCANoptimize.读取生产日期]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 写入生产日期(int 通道, out string 响应值, out string 命令, out string 信息)
//        {
//            信息 = "";
//            响应值 = "";
//            命令 = $"06 2E F1 8B {DateTime.UtcNow.ToString("yy")} {DateTime.UtcNow.ToString("MM")} {DateTime.UtcNow.ToString("dd")} AA";
//            try
//            {
//                //命令 = "06 2E F1 8B 24 07 26 00";
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = 命令 });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = true;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 1;
//                requestModel.AutoParse = false;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                var 提取结果 = 数据.GetFrameHeaderData(发送响应.ResultList, "03 6E F1 8B", out string 目标值);
//                if (!提取结果)
//                {
//                    信息 = "写入生产日期失败";
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;  //指定数据帧不存在
//                }

//                信息 = "写入生产日期成功";
//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.写入生产日期]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.写入生产日期]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 硬件系统供应商标识号(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 8A 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 3;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultAsc.Insert(4, "/");

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.硬件系统供应商标识号]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.硬件系统供应商标识号]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读NVM版本号(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 4C E8 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 3;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读NVM版本号]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读NVM版本号]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读取产品供电电压(int 通道, out double 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = 0.0;
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 B1 06 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 3;
//                requestModel.AutoParse = false;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = -1.0;
//                var 提取结果 = 数据.GetFrameHeaderData(发送响应.ResultList, "10", out string 目标值);
//                if (!提取结果)
//                {
//                    return false;  //指定数据帧不存在
//                }
//                int 电压值Int = Convert.ToInt32(目标值.Substring(10, 2), 16);
//                响应值 = (double)电压值Int / 10.0; ;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读取产品供电电压]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读取产品供电电压]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = -3.0;
//                throw;  //向上抛出异常
//            }
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读取MPU零件号(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 B1 10 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 3;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultAsc.Insert(4, "/").Substring(0, 6);  //插入符号后，只需取前面6个长度的数据

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读取MPU零件号]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读取MPU零件号]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读SOC软件版本号(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 B1 0C 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 3;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultHex;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读SOC软件版本号]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读SOC软件版本号]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读电控单元引导加载软件参考号F183(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 83 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 3;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读电控单元引导加载软件参考号F183]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读电控单元引导加载软件参考号F183]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读取物流标定数据C00C(int 通道, out string 响应值, out string 信息)
//        {
//            响应值 = "";

//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 C0 0C 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultHex;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读取物流标定数据C00C]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读取物流标定数据C00C]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }



//        //================================ 返回值：BCD模式 =========================================
//        [ExposedMethodAttribute("")]
//        public bool 读ECU零件号F187(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 87 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultHex;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读ECU零件号F187]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读ECU零件号F187]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读系统供应商标识号F18A(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 8A 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultHex;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读系统供应商标识号F18A]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读系统供应商标识号F18A]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读ECU应用软件号F1A0(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";

//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 A0 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultHex;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读ECU应用软件号F1A0]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读ECU应用软件号F1A0]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读ECU配置文件编号F1A9(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";

//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 A9 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultHex;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读ECU配置文件编号F1A9]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读ECU配置文件编号F1A9]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读ECU编程过程文件编号F1AA(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";

//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 AA 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultHex;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读ECU编程过程文件编号F1AA]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读ECU编程过程文件编号F1AA]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读ECU二级应用软件F1B5(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";

//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 B5 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultHex;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读ECU二级应用软件F1B5]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读ECU二级应用软件F1B5]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读ECU三级应用软件号F1B6(int 通道, out string 响应值, out int 字节长度, out string 信息)
//        {
//            响应值 = "";
//            字节长度 = 0;
//            信息 = "";

//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 B6 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值 = 发送响应.ResultHex;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读ECU三级应用软件号F1B6]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读ECU三级应用软件号F1B6]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }



//        //================================ 返回值：HEX + ASCII 模式 =========================================
//        [ExposedMethodAttribute("")]
//        public bool 读供应商硬件参考编号F192(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 92 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读供应商硬件参考编号F192]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读供应商硬件参考编号F192]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读系统供应商软件参考编号F194(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 94 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读系统供应商软件参考编号F194]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读系统供应商软件参考编号F194]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读配置可追溯字段F198(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 98 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读配置可追溯字段F198]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读配置可追溯字段F198]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读ECUNCF参考编号F1A2(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 A2 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读ECUNCF参考编号F1A2]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读ECUNCF参考编号F1A2]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读ECU索引信息F1A5(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 A5 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读ECU索引信息F1A5]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读ECU索引信息F1A5]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读车辆功能信息F1A8(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 A8 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //  LogHelper.Error($"[版本信息.读车辆功能信息F1A8]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读车辆功能信息F1A8]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读SVIF数据F100(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 00 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读SVIF数据F100]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读SVIF数据F100]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读ECU装配日期数据4CE4(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 4C E4 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                // LogHelper.Error($"[版本信息.读ECU装配日期数据4CE4]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读ECU装配日期数据4CE4]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读取LIN数据4CE7(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 4C E7 00 AA AA AA" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读取LIN数据4CE7]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读取LIN数据4CE7]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读取MPU版本号B111(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 B1 11 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读取MPU版本号B111]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读取MPU版本号B111]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读NVM版本号4CE8(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 4C E8 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读NVM版本号4CE8]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读NVM版本号4CE8]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读SOC软件版本号B10C(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 B1 0C 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读SOC软件版本号B10C]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读SOC软件版本号B10C]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读ECU硬件版本号F191(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 91 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读ECU硬件版本号F191]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读ECU硬件版本号F191]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }


//        //=================================== 2024-09-27 ELO指令更新，以下方法为对应更新的内容 ==========================================
//        [ExposedMethodAttribute("")]
//        public bool 写ECU生产日期F18B(int 通道, out string 响应值, out string 命令, out string 信息)
//        {
//            信息 = "";
//            响应值 = "";
//            命令 = $"06 2E F1 8B {DateTime.UtcNow.ToString("yy")} {DateTime.UtcNow.ToString("MM")} {DateTime.UtcNow.ToString("dd")} AA";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = 命令 });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = true;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 1;
//                requestModel.AutoParse = false;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                var 提取结果 = 数据.GetFrameHeaderData(发送响应.ResultList, "03 6E F1 8B", out string 目标值);
//                if (!提取结果)
//                {
//                    信息 = "写入ECU生产日期失败";
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;  //指定数据帧不存在
//                }

//                信息 = "写入ECU生产日期成功";
//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[HomeViewModel.写ECU生产日期F18B]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[HomeViewModel.写ECU生产日期F18B]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 写配置可追溯字段F198(int 通道, out string 响应值, out string 命令, out string 信息)
//        {
//            信息 = "";
//            响应值 = "";
//            命令 = "";
//            try
//            {
//                /*
//                    10 0E 2E F1 98 31 33 33
//                    21 33 33 33 33 33 33 33
//                    22 39 00 00 00 00 00 00 
//                */
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "10 0E 2E F1 98 31 33 33" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "21 33 33 33 33 33 33 33" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "22 39 00 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = true;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 1;
//                requestModel.AutoParse = false;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                var 提取结果 = 数据.GetFrameHeaderData(发送响应.ResultList, "03 6E F1 98", out string 目标值);
//                if (!提取结果)
//                {
//                    信息 = "写入配置可追溯字段失败";
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;  //指定数据帧不存在
//                }

//                信息 = "写入配置可追溯字段成功";
//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[HomeViewModel.写配置可追溯字段F198]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[HomeViewModel.写配置可追溯字段F198]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 写车辆功能信息F1A8(int 通道, out string 响应值, out string 信息)
//        {
//            信息 = "";
//            响应值 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "10 17 2E F1 A8 FF FF FF" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "21 FF FF FF FF FF FF FF" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "22 FF FF FF FF FF FF FF" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "23 FF FF F1 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = true;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 1;
//                requestModel.AutoParse = false;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                var 提取结果 = 数据.GetFrameHeaderData(发送响应.ResultList, "03 6E F1 A8", out string 目标值);
//                if (!提取结果)
//                {
//                    信息 = "写车辆功能信息失败";
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;  //指定数据帧不存在
//                }

//                信息 = "写车辆功能信息成功";
//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[HomeViewModel.写车辆功能信息F1A8]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[HomeViewModel.写车辆功能信息F1A8]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 写ECU配置文件编号F1A9(int 通道, out string 响应值, out string 信息)
//        {
//            信息 = "";
//            响应值 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "10 08 2E F1 A9 31 33 33" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "21 33 34 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = true;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 1;
//                requestModel.AutoParse = false;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                var 提取结果 = 数据.GetFrameHeaderData(发送响应.ResultList, "03 6E F1 A9", out string 目标值);
//                if (!提取结果)
//                {
//                    信息 = "写ECU配置文件编号失败";
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;  //指定数据帧不存在
//                }

//                信息 = "写ECU配置文件编号成功";
//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[HomeViewModel.写ECU配置文件编号F1A9]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[HomeViewModel.写ECU配置文件编号F1A9]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 写ECU装配日期数据4CE4(int 通道, out string 响应值, out string 信息)
//        {
//            信息 = "";
//            响应值 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "10 0B 2E 4C E4 33 33 33" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "21 33 33 33 33 34 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = true;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 1;
//                requestModel.AutoParse = false;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    信息 = 发送响应.ErrorMessage;
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                var 提取结果 = 数据.GetFrameHeaderData(发送响应.ResultList, "03 6E 4C E4", out string 目标值);
//                if (!提取结果)
//                {
//                    信息 = "写ECU装配日期数据失败";
//                    响应值 = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;  //指定数据帧不存在
//                }

//                信息 = "写ECU装配日期数据成功";
//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[HomeViewModel.写ECU装配日期数据4CE4]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[HomeViewModel.写ECU装配日期数据4CE4]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值 = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读EOL配置版本号B10A(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 B1 0A 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读EOL配置版本号B10A]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读EOL配置版本号B10A]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读4G模块ICCID信息B001(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 B0 01 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读4G模块ICCID信息B001]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读4G模块ICCID信息B001]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读4G模块IMEI信息B002(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 B0 02 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读4G模块IMEI信息B002]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读4G模块IMEI信息B002]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读4G模块软件版本号B003(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 B0 03 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读4G模块软件版本号B003]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读4G模块软件版本号B003]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读4G模块IMSI信息4C60(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 4C 60 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读4G模块IMSI信息4C60]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读4G模块IMSI信息4C60]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读4G模块MSISDN信息4CD0(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 4C D0 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读4G模块MSISDN信息4CD0]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读4G模块MSISDN信息4CD0]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读NIF工厂数据F120(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 20 00 00 00 00" });
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "30 08 14 00 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读NIF工厂数据F120]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读NIF工厂数据F120]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//        [ExposedMethodAttribute("")]
//        public bool 读NIF当前数据F121(int 通道, out string 响应值Hex, out string 响应值Asc, out int 字节长度, out string 信息)
//        {
//            响应值Hex = "";
//            响应值Asc = "";
//            字节长度 = 0;
//            信息 = "";
//            try
//            {
//                List<CanCmdModel> cmdList = new List<CanCmdModel>();
//                cmdList.Add(new CanCmdModel() { Id = 0x761, cmd = "03 22 F1 21 00 00 00 00" });
//                CanReadRequestModel requestModel = new CanReadRequestModel();
//                requestModel.Channel = (ushort)通道;
//                requestModel.IsClearCache = true;
//                requestModel.IsDecode = false;
//                requestModel.DecodeLevel = "62";
//                requestModel.CmdList = cmdList;
//                requestModel.SendCmdTimeSpan = 50;
//                requestModel.MaxSendCount = 5;
//                requestModel.AutoParse = true;
//                requestModel.IsVerifyDid = true;
//                requestModel.RequestMode = CanRequestMode.发送并接收;

//                var 发送响应 = 数据.发送指令(requestModel);
//                if (发送响应.Success == false)
//                {
//                    字节长度 = 发送响应.ResultList.Count();
//                    信息 = 发送响应.ErrorMessage;
//                    响应值Hex = string.Join(",", 发送响应.ResultList ?? new List<string>());
//                    return false;
//                }

//                信息 = string.Join(",", 发送响应.ResultList);
//                响应值Hex = 发送响应.ResultHex;
//                响应值Asc = 发送响应.ResultAsc;

//                return true;
//            }
//            catch (Exception ex)
//            {
//                //LogHelper.Error($"[版本信息.读NIF当前数据F121]异常，{ex.Message}，{ex.StackTrace}");
//                eLog.AddLog($"[版本信息.读NIF当前数据F121]异常，{ex.Message}，{ex.StackTrace}", eMsgType.Error);
//                信息 = ex.Message;
//                响应值Hex = 信息;
//            }
//            return false;
//        }
//    }
}
